ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ಜನರೇಟರ್ ರಿಟರ್ನ್ ಮೌಲ್ಯ: ವರ್ಧಿತ ಇಟರೇಟರ್ ಪ್ರೋಟೋಕಾಲ್ ಅನ್ನು ಮಾಸ್ಟರಿಂಗ್ ಮಾಡುವುದು

ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ಜನರೇಟರ್‌ಗಳು ಇಟರೇಬಲ್ ಆಬ್ಜೆಕ್ಟ್‌ಗಳನ್ನು ರಚಿಸಲು ಮತ್ತು ಸಂಕೀರ್ಣ ಅಸಿಂಕ್ರೋನಸ್ ಕಾರ್ಯಾಚರಣೆಗಳನ್ನು ನಿರ್ವಹಿಸಲು ಒಂದು ಶಕ್ತಿಯುತ ವ್ಯವಸ್ಥೆಯನ್ನು ಒದಗಿಸುತ್ತವೆ. ಜನರೇಟರ್‌ಗಳ ಪ್ರಮುಖ ಕಾರ್ಯಚಟುವಟಿಕೆಯು yield ಕೀವರ್ಡ್‌ನ ಸುತ್ತ ಸುತ್ತುತ್ತಿದ್ದರೂ, ಅವುಗಳ ಪೂರ್ಣ ಸಾಮರ್ಥ್ಯವನ್ನು ಬಳಸಿಕೊಳ್ಳಲು ಜನರೇಟರ್‌ಗಳೊಳಗಿನ return ಸ್ಟೇಟ್‌ಮೆಂಟ್‌ನ ಸೂಕ್ಷ್ಮ ವ್ಯತ್ಯಾಸಗಳನ್ನು ಅರ್ಥಮಾಡಿಕೊಳ್ಳುವುದು ಬಹಳ ಮುಖ್ಯ. ಈ ಲೇಖನವು ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ಜನರೇಟರ್ ರಿಟರ್ನ್ ಮೌಲ್ಯಗಳು ಮತ್ತು ವರ್ಧಿತ ಇಟರೇಟರ್ ಪ್ರೋಟೋಕಾಲ್‌ನ ಬಗ್ಗೆ ಸಮಗ್ರ ಪರಿಶೋಧನೆಯನ್ನು ಒದಗಿಸುತ್ತದೆ, ಎಲ್ಲಾ ಹಂತದ ಡೆವಲಪರ್‌ಗಳಿಗೆ ಪ್ರಾಯೋಗಿಕ ಉದಾಹರಣೆಗಳು ಮತ್ತು ಒಳನೋಟಗಳನ್ನು ನೀಡುತ್ತದೆ.

ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ಜನರೇಟರ್‌ಗಳು ಮತ್ತು ಇಟರೇಟರ್‌ಗಳನ್ನು ಅರ್ಥಮಾಡಿಕೊಳ್ಳುವುದು

ಜನರೇಟರ್ ರಿಟರ್ನ್ ಮೌಲ್ಯಗಳ ನಿರ್ದಿಷ್ಟತೆಗಳಿಗೆ ಹೋಗುವ ಮೊದಲು, ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್‌ನಲ್ಲಿನ ಜನರೇಟರ್‌ಗಳು ಮತ್ತು ಇಟರೇಟರ್‌ಗಳ ಮೂಲಭೂತ ಪರಿಕಲ್ಪನೆಗಳನ್ನು ಸಂಕ್ಷಿಪ್ತವಾಗಿ ಪರಿಶೀಲಿಸೋಣ.

ಜನರೇಟರ್‌ಗಳು ಎಂದರೇನು?

ಜನರೇಟರ್‌ಗಳು ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್‌ನಲ್ಲಿನ ಒಂದು ವಿಶೇಷ ರೀತಿಯ ಫಂಕ್ಷನ್‌ಗಳಾಗಿದ್ದು, ಅವುಗಳನ್ನು ವಿರಾಮಗೊಳಿಸಿ ಪುನರಾರಂಭಿಸಬಹುದು, ಕಾಲಾನಂತರದಲ್ಲಿ ಮೌಲ್ಯಗಳ ಅನುಕ್ರಮವನ್ನು ಉತ್ಪಾದಿಸಲು ನಿಮಗೆ ಅನುವು ಮಾಡಿಕೊಡುತ್ತದೆ. ಅವುಗಳನ್ನು function* ಸಿಂಟ್ಯಾಕ್ಸ್ ಬಳಸಿ ವ್ಯಾಖ್ಯಾನಿಸಲಾಗುತ್ತದೆ ಮತ್ತು ಮೌಲ್ಯಗಳನ್ನು ಹೊರಸೂಸಲು yield ಕೀವರ್ಡ್ ಅನ್ನು ಬಳಸುತ್ತವೆ.

ಉದಾಹರಣೆ: ಒಂದು ಸರಳ ಜನರೇಟರ್ ಫಂಕ್ಷನ್

            function* numberGenerator() {
 yield 1;
 yield 2;
 yield 3;
}

const generator = numberGenerator();

console.log(generator.next()); // Output: { value: 1, done: false }
console.log(generator.next()); // Output: { value: 2, done: false }
console.log(generator.next()); // Output: { value: 3, done: false }
console.log(generator.next()); // Output: { value: undefined, done: true }

            

              
                Copy
              
            
          

ಇಟರೇಟರ್‌ಗಳು ಎಂದರೇನು?

ಇಟರೇಟರ್ ಎನ್ನುವುದು ಒಂದು ಅನುಕ್ರಮವನ್ನು ಮತ್ತು ಆ ಅನುಕ್ರಮದಿಂದ ಒಂದೊಂದಾಗಿ ಮೌಲ್ಯಗಳನ್ನು ಪ್ರವೇಶಿಸುವ ವಿಧಾನವನ್ನು ವ್ಯಾಖ್ಯಾನಿಸುವ ಒಂದು ಆಬ್ಜೆಕ್ಟ್ ಆಗಿದೆ. ಇಟರೇಟರ್‌ಗಳು ಇಟರೇಟರ್ ಪ್ರೋಟೋಕಾಲ್ ಅನ್ನು ಅಳವಡಿಸುತ್ತವೆ, ಅದಕ್ಕೆ next() ಮೆಥಡ್ ಅಗತ್ಯವಿದೆ. next() ಮೆಥಡ್ ಎರಡು ಪ್ರಾಪರ್ಟಿಗಳನ್ನು ಹೊಂದಿರುವ ಒಂದು ಆಬ್ಜೆಕ್ಟ್ ಅನ್ನು ಹಿಂತಿರುಗಿಸುತ್ತದೆ:

• value: ಅನುಕ್ರಮದಲ್ಲಿನ ಮುಂದಿನ ಮೌಲ್ಯ.
• done: ಅನುಕ್ರಮವು ಮುಗಿದಿದೆಯೇ ಎಂದು ಸೂಚಿಸುವ ಒಂದು ಬೂಲಿಯನ್.

ಜನರೇಟರ್‌ಗಳು ಸ್ವಯಂಚಾಲಿತವಾಗಿ ಇಟರೇಟರ್‌ಗಳನ್ನು ರಚಿಸುತ್ತವೆ, ಇದು ಇಟರೇಬಲ್ ಆಬ್ಜೆಕ್ಟ್‌ಗಳನ್ನು ರಚಿಸುವ ಪ್ರಕ್ರಿಯೆಯನ್ನು ಸರಳಗೊಳಿಸುತ್ತದೆ.

ಜನರೇಟರ್‌ಗಳಲ್ಲಿ 'return' ಪಾತ್ರ

ಜನರೇಟರ್‌ನಿಂದ ಮೌಲ್ಯಗಳನ್ನು ಉತ್ಪಾದಿಸಲು yield ಪ್ರಾಥಮಿಕ ವ್ಯವಸ್ಥೆಯಾಗಿದ್ದರೂ, return ಸ್ಟೇಟ್‌ಮೆಂಟ್ ಇಟರೇಶನ್‌ನ ಅಂತ್ಯವನ್ನು ಸೂಚಿಸುವಲ್ಲಿ ಮತ್ತು ಐಚ್ಛಿಕವಾಗಿ ಅಂತಿಮ ಮೌಲ್ಯವನ್ನು ಒದಗಿಸುವಲ್ಲಿ ಪ್ರಮುಖ ಪಾತ್ರ ವಹಿಸುತ್ತದೆ.

'return' ನ ಮೂಲಭೂತ ಬಳಕೆ

ಜನರೇಟರ್‌ನೊಳಗೆ return ಸ್ಟೇಟ್‌ಮೆಂಟ್ ಎದುರಾದಾಗ, ಇಟರೇಟರ್‌ನ done ಪ್ರಾಪರ್ಟಿಯನ್ನು true ಗೆ ಹೊಂದಿಸಲಾಗುತ್ತದೆ, ಇದು ಇಟರೇಶನ್ ಪೂರ್ಣಗೊಂಡಿದೆ ಎಂದು ಸೂಚಿಸುತ್ತದೆ. ಒಂದು ವೇಳೆ return ಸ್ಟೇಟ್‌ಮೆಂಟ್‌ನೊಂದಿಗೆ ಮೌಲ್ಯವನ್ನು ಒದಗಿಸಿದರೆ, ಅದು next() ಮೆಥಡ್‌ನಿಂದ ಹಿಂತಿರುಗಿದ ಕೊನೆಯ ಆಬ್ಜೆಕ್ಟ್‌ನ value ಪ್ರಾಪರ್ಟಿ ಆಗುತ್ತದೆ. next() ಗೆ ನಂತರದ ಕರೆಗಳು { value: undefined, done: true } ಅನ್ನು ಹಿಂತಿರುಗಿಸುತ್ತವೆ.

ಉದಾಹರಣೆ: ಇಟರೇಶನ್ ಅನ್ನು ಕೊನೆಗೊಳಿಸಲು 'return' ಬಳಸುವುದು

            function* generatorWithReturn() {
 yield 1;
 yield 2;
 return 3;
}

const generator = generatorWithReturn();

console.log(generator.next()); // Output: { value: 1, done: false }
console.log(generator.next()); // Output: { value: 2, done: false }
console.log(generator.next()); // Output: { value: 3, done: true }
console.log(generator.next()); // Output: { value: undefined, done: true }

            

              
                Copy
              
            
          

ಈ ಉದಾಹರಣೆಯಲ್ಲಿ, return 3; ಸ್ಟೇಟ್‌ಮೆಂಟ್ ಇಟರೇಶನ್ ಅನ್ನು ಕೊನೆಗೊಳಿಸುತ್ತದೆ ಮತ್ತು ಕೊನೆಯದಾಗಿ ಹಿಂತಿರುಗಿದ ಆಬ್ಜೆಕ್ಟ್‌ನ value ಪ್ರಾಪರ್ಟಿಯನ್ನು 3 ಕ್ಕೆ ಹೊಂದಿಸುತ್ತದೆ.

'return' ವಿರುದ್ಧ ಸೂಚ್ಯ ಪೂರ್ಣಗೊಳಿಸುವಿಕೆ

ಒಂದು ಜನರೇಟರ್ ಫಂಕ್ಷನ್ return ಸ್ಟೇಟ್‌ಮೆಂಟ್ ಇಲ್ಲದೆ ಕೊನೆಗೊಂಡರೆ, ಇಟರೇಟರ್‌ನ done ಪ್ರಾಪರ್ಟಿ ಇನ್ನೂ true ಗೆ ಹೊಂದಿಸಲ್ಪಡುತ್ತದೆ. ಆದಾಗ್ಯೂ, next() ನಿಂದ ಹಿಂತಿರುಗಿದ ಕೊನೆಯ ಆಬ್ಜೆಕ್ಟ್‌ನ value ಪ್ರಾಪರ್ಟಿ undefined ಆಗಿರುತ್ತದೆ.

ಉದಾಹರಣೆ: ಸೂಚ್ಯ ಪೂರ್ಣಗೊಳಿಸುವಿಕೆ

            function* generatorWithoutReturn() {
 yield 1;
 yield 2;
}

const generator = generatorWithoutReturn();

console.log(generator.next()); // Output: { value: 1, done: false }
console.log(generator.next()); // Output: { value: 2, done: false }
console.log(generator.next()); // Output: { value: undefined, done: true }
console.log(generator.next()); // Output: { value: undefined, done: true }

            

              
                Copy
              
            
          

ಆದ್ದರಿಂದ, ಇಟರೇಟರ್‌ನಿಂದ ಹಿಂತಿರುಗಿಸಬೇಕಾದ ಅಂತಿಮ ಮೌಲ್ಯವನ್ನು ಸ್ಪಷ್ಟವಾಗಿ ನಿರ್ದಿಷ್ಟಪಡಿಸಬೇಕಾದಾಗ return ಬಳಸುವುದು ಬಹಳ ಮುಖ್ಯ.

ವರ್ಧಿತ ಇಟರೇಟರ್ ಪ್ರೋಟೋಕಾಲ್ ಮತ್ತು 'return'

ಇಟರೇಟರ್ ಪ್ರೋಟೋಕಾಲ್ ಅನ್ನು ಇಟರೇಟರ್ ಆಬ್ಜೆಕ್ಟ್‌ನಲ್ಲಿಯೇ return(value) ಮೆಥಡ್ ಅನ್ನು ಸೇರಿಸಲು ವರ್ಧಿಸಲಾಗಿದೆ. ಈ ಮೆಥಡ್, ಇಟರೇಟರ್‌ನ ಗ್ರಾಹಕನಿಗೆ ಜನರೇಟರ್‌ನಿಂದ ಮತ್ತಷ್ಟು ಮೌಲ್ಯಗಳನ್ನು ಸ್ವೀಕರಿಸಲು ಇನ್ನು ಮುಂದೆ ಆಸಕ್ತಿ ಇಲ್ಲ ಎಂದು ಸಂಕೇತಿಸಲು ಅನುವು ಮಾಡಿಕೊಡುತ್ತದೆ. ಇಟರೇಶನ್ ಅನ್ನು ಅಕಾಲಿಕವಾಗಿ ಕೊನೆಗೊಳಿಸಿದಾಗ ಜನರೇಟರ್‌ನೊಳಗೆ ಸಂಪನ್ಮೂಲಗಳನ್ನು ನಿರ್ವಹಿಸಲು ಅಥವಾ ಸ್ಥಿತಿಯನ್ನು ಸ್ವಚ್ಛಗೊಳಿಸಲು ಇದು ವಿಶೇಷವಾಗಿ ಮುಖ್ಯವಾಗಿದೆ.

'return(value)' ಮೆಥಡ್

ಇಟರೇಟರ್‌ನಲ್ಲಿ return(value) ಮೆಥಡ್ ಅನ್ನು ಕರೆದಾಗ, ಈ ಕೆಳಗಿನವುಗಳು ಸಂಭವಿಸುತ್ತವೆ:

1. ಜನರೇಟರ್ ಪ್ರಸ್ತುತ yield ಸ್ಟೇಟ್‌ಮೆಂಟ್‌ನಲ್ಲಿ ಸ್ಥಗಿತಗೊಂಡಿದ್ದರೆ, ಜನರೇಟರ್ ಕಾರ್ಯಗತಗೊಳಿಸುವುದನ್ನು ಪುನರಾರಂಭಿಸುತ್ತದೆ, ಒದಗಿಸಲಾದ value ನೊಂದಿಗೆ return ಸ್ಟೇಟ್‌ಮೆಂಟ್ ಆ ಹಂತದಲ್ಲಿ ಎದುರಾದಂತೆ.
2. ಜನರೇಟರ್ ನಿಜವಾಗಿ ಹಿಂತಿರುಗುವ ಮೊದಲು ಯಾವುದೇ ಅಗತ್ಯ ಸ್ವಚ್ಛತಾ ಅಥವಾ ಅಂತಿಮಗೊಳಿಸುವ ತರ್ಕವನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸಬಹುದು.
3. ಇಟರೇಟರ್‌ನ done ಪ್ರಾಪರ್ಟಿಯನ್ನು true ಗೆ ಹೊಂದಿಸಲಾಗುತ್ತದೆ.

ಉದಾಹರಣೆ: ಇಟರೇಶನ್ ಅನ್ನು ಕೊನೆಗೊಳಿಸಲು 'return(value)' ಬಳಸುವುದು

            function* generatorWithCleanup() {
 try {
 yield 1;
 yield 2;
 } finally {
 console.log("Cleaning up...");
 }
}

const generator = generatorWithCleanup();

console.log(generator.next()); // Output: { value: 1, done: false }
console.log(generator.return("Done")); // Output: Cleaning up...
 // Output: { value: "Done", done: true }
console.log(generator.next()); // Output: { value: undefined, done: true }

            

              
                Copy
              
            
          

ಈ ಉದಾಹರಣೆಯಲ್ಲಿ, generator.return("Done") ಎಂದು ಕರೆಯುವುದು finally ಬ್ಲಾಕ್ ಅನ್ನು ಪ್ರಚೋದಿಸುತ್ತದೆ, ಇದು ಇಟರೇಶನ್ ಅನ್ನು ಕೊನೆಗೊಳಿಸುವ ಮೊದಲು ಜನರೇಟರ್‌ಗೆ ಸ್ವಚ್ಛತೆಯನ್ನು ನಿರ್ವಹಿಸಲು ಅನುವು ಮಾಡಿಕೊಡುತ್ತದೆ.

ಜನರೇಟರ್ ಒಳಗೆ 'return(value)' ಅನ್ನು ನಿರ್ವಹಿಸುವುದು

ಜನರೇಟರ್ ಫಂಕ್ಷನ್ ಒಳಗೆ, ನೀವು return(value) ಮೆಥಡ್‌ಗೆ ರವಾನಿಸಲಾದ ಮೌಲ್ಯವನ್ನು try...finally ಬ್ಲಾಕ್ ಹಾಗೂ yield ಕೀವರ್ಡ್‌ನೊಂದಿಗೆ ಪ್ರವೇಶಿಸಬಹುದು. return(value) ಅನ್ನು ಕರೆದಾಗ, ಜನರೇಟರ್ ಅದು ವಿರಾಮಗೊಂಡಿದ್ದ ಸ್ಥಳದಲ್ಲಿ ಪರಿಣಾಮಕಾರಿಯಾಗಿ return value; ಸ್ಟೇಟ್‌ಮೆಂಟ್ ಅನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸುತ್ತದೆ.

ಉದಾಹರಣೆ: ಜನರೇಟರ್ ಒಳಗೆ ರಿಟರ್ನ್ ಮೌಲ್ಯವನ್ನು ಪ್ರವೇಶಿಸುವುದು

            function* generatorWithValue() {
 try {
 yield 1;
 yield 2;
 } finally {
 // This will execute when return() is called
 console.log("Finally block executed");
 }
 return "Generator finished";
}

const gen = generatorWithValue();
console.log(gen.next()); // {value: 1, done: false}
console.log(gen.return("Custom Return Value")); // {value: "Custom Return Value", done: true}

            

              
                Copy
              
            
          

ಗಮನಿಸಿ: ಜನರೇಟರ್ ಈಗಾಗಲೇ ಪೂರ್ಣಗೊಂಡ ನಂತರ (ಅಂದರೆ, done ಈಗಾಗಲೇ true ಆಗಿದ್ದರೆ) return(value) ಮೆಥಡ್ ಅನ್ನು ಕರೆದರೆ, `return()` ಗೆ ರವಾನಿಸಲಾದ value ಅನ್ನು ಕಡೆಗಣಿಸಲಾಗುತ್ತದೆ ಮತ್ತು ಮೆಥಡ್ ಸರಳವಾಗಿ `{ value: undefined, done: true }` ಅನ್ನು ಹಿಂತಿರುಗಿಸುತ್ತದೆ.

ಜನರೇಟರ್ ರಿಟರ್ನ್ ಮೌಲ್ಯಗಳಿಗಾಗಿ ಪ್ರಾಯೋಗಿಕ ಬಳಕೆಯ ಪ್ರಕರಣಗಳು

ಜನರೇಟರ್ ರಿಟರ್ನ್ ಮೌಲ್ಯಗಳನ್ನು ಮತ್ತು ವರ್ಧಿತ ಇಟರೇಟರ್ ಪ್ರೋಟೋಕಾಲ್ ಅನ್ನು ಅರ್ಥಮಾಡಿಕೊಳ್ಳುವುದು ಹೆಚ್ಚು ಅತ್ಯಾಧುನಿಕ ಮತ್ತು ದೃಢವಾದ ಅಸಿಂಕ್ರೋನಸ್ ಕೋಡ್ ಅನ್ನು ಅಳವಡಿಸಲು ನಿಮಗೆ ಅನುವು ಮಾಡಿಕೊಡುತ್ತದೆ. ಕೆಲವು ಪ್ರಾಯೋಗಿಕ ಬಳಕೆಯ ಪ್ರಕರಣಗಳು ಇಲ್ಲಿವೆ:

ಸಂಪನ್ಮೂಲ ನಿರ್ವಹಣೆ

ಫೈಲ್ ಹ್ಯಾಂಡಲ್‌ಗಳು, ಡೇಟಾಬೇಸ್ ಸಂಪರ್ಕಗಳು, ಅಥವಾ ನೆಟ್‌ವರ್ಕ್ ಸಾಕೆಟ್‌ಗಳಂತಹ ಸಂಪನ್ಮೂಲಗಳನ್ನು ನಿರ್ವಹಿಸಲು ಜನರೇಟರ್‌ಗಳನ್ನು ಬಳಸಬಹುದು. ಇಟರೇಶನ್ ಇನ್ನು ಮುಂದೆ ಅಗತ್ಯವಿಲ್ಲದಿದ್ದಾಗ ಈ ಸಂಪನ್ಮೂಲಗಳನ್ನು ಬಿಡುಗಡೆ ಮಾಡಲು return(value) ಮೆಥಡ್ ಒಂದು ವ್ಯವಸ್ಥೆಯನ್ನು ಒದಗಿಸುತ್ತದೆ, ಇದರಿಂದ ಸಂಪನ್ಮೂಲ ಸೋರಿಕೆಯನ್ನು ತಡೆಯುತ್ತದೆ.

ಉದಾಹರಣೆ: ಫೈಲ್ ಸಂಪನ್ಮೂಲವನ್ನು ನಿರ್ವಹಿಸುವುದು

            function* fileReader(filePath) {
 let fileHandle;
 try {
 fileHandle = openFile(filePath); // Assume openFile() opens the file
 yield readFileChunk(fileHandle); // Assume readFileChunk() reads a chunk
 yield readFileChunk(fileHandle);
 } finally {
 if (fileHandle) {
 closeFile(fileHandle); // Ensure the file is closed
 console.log("File closed.");
 }
 }
}

const reader = fileReader("data.txt");
console.log(reader.next());
reader.return(); // Close the file and release the resource

            

              
                Copy
              
            
          

ಈ ಉದಾಹರಣೆಯಲ್ಲಿ, finally ಬ್ಲಾಕ್, ದೋಷ ಸಂಭವಿಸಿದರೂ ಅಥವಾ ಇಟರೇಶನ್ ಅಕಾಲಿಕವಾಗಿ ಕೊನೆಗೊಂಡರೂ ಫೈಲ್ ಯಾವಾಗಲೂ ಮುಚ್ಚಲ್ಪಡುವುದನ್ನು ಖಚಿತಪಡಿಸುತ್ತದೆ.

ರದ್ದತಿಯೊಂದಿಗೆ ಅಸಿಂಕ್ರೋನಸ್ ಕಾರ್ಯಾಚರಣೆಗಳು

ಸಂಕೀರ್ಣ ಅಸಿಂಕ್ರೋನಸ್ ಕಾರ್ಯಾಚರಣೆಗಳನ್ನು ಸಂಘಟಿಸಲು ಜನರೇಟರ್‌ಗಳನ್ನು ಬಳಸಬಹುದು. ಈ ಕಾರ್ಯಾಚರಣೆಗಳು ಇನ್ನು ಮುಂದೆ ಅಗತ್ಯವಿಲ್ಲದಿದ್ದರೆ ಅವುಗಳನ್ನು ರದ್ದುಗೊಳಿಸಲು return(value) ಮೆಥಡ್ ಒಂದು ಮಾರ್ಗವನ್ನು ಒದಗಿಸುತ್ತದೆ, ಅನಗತ್ಯ ಕೆಲಸವನ್ನು ತಡೆಯುತ್ತದೆ ಮತ್ತು ಕಾರ್ಯಕ್ಷಮತೆಯನ್ನು ಸುಧಾರಿಸುತ್ತದೆ.

ಉದಾಹರಣೆ: ಅಸಿಂಕ್ರೋನಸ್ ಕಾರ್ಯವನ್ನು ರದ್ದುಗೊಳಿಸುವುದು

            function* longRunningTask() {
 let cancelled = false;
 try {
 console.log("Starting task...");
 yield delay(2000); // Assume delay() returns a Promise
 console.log("Task completed.");
 } finally {
 if (cancelled) {
 console.log("Task cancelled.");
 }
 }
}

function delay(ms) {
 return new Promise(resolve => setTimeout(resolve, ms));
}

const task = longRunningTask();
task.next();

setTimeout(() => {
 task.return(); // Cancel the task after 1 second
}, 1000);

            

              
                Copy
              
            
          

ಈ ಉದಾಹರಣೆಯಲ್ಲಿ, 1 ಸೆಕೆಂಡಿನ ನಂತರ return() ಮೆಥಡ್ ಅನ್ನು ಕರೆಯಲಾಗುತ್ತದೆ, ದೀರ್ಘಕಾಲದ ಕಾರ್ಯವು ಪೂರ್ಣಗೊಳ್ಳುವ ಮೊದಲು ಅದನ್ನು ರದ್ದುಗೊಳಿಸುತ್ತದೆ. ಬಳಕೆದಾರರ ರದ್ದತಿ ಅಥವಾ ಟೈಮ್‌ಔಟ್‌ಗಳಂತಹ ವೈಶಿಷ್ಟ್ಯಗಳನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸಲು ಇದು ಉಪಯುಕ್ತವಾಗಬಹುದು.

ಅಡ್ಡ ಪರಿಣಾಮಗಳನ್ನು ಸ್ವಚ್ಛಗೊಳಿಸುವುದು

ಗ್ಲೋಬಲ್ ಸ್ಥಿತಿಯನ್ನು ಮಾರ್ಪಡಿಸುವುದು ಅಥವಾ ಬಾಹ್ಯ ವ್ಯವಸ್ಥೆಗಳೊಂದಿಗೆ ಸಂವಹನ ನಡೆಸುವುದು ಮುಂತಾದ ಅಡ್ಡ ಪರಿಣಾಮಗಳನ್ನು ಹೊಂದಿರುವ ಕ್ರಿಯೆಗಳನ್ನು ನಿರ್ವಹಿಸಲು ಜನರೇಟರ್‌ಗಳನ್ನು ಬಳಸಬಹುದು. ಜನರೇಟರ್ ಮುಗಿದಾಗ ಈ ಅಡ್ಡ ಪರಿಣಾಮಗಳನ್ನು ಸರಿಯಾಗಿ ಸ್ವಚ್ಛಗೊಳಿಸಲಾಗಿದೆಯೆ ಎಂದು return(value) ಮೆಥಡ್ ಖಚಿತಪಡಿಸುತ್ತದೆ, ಅನಿರೀಕ್ಷಿತ ನಡವಳಿಕೆಯನ್ನು ತಡೆಯುತ್ತದೆ.

ಉದಾಹರಣೆ: ತಾತ್ಕಾಲಿಕ ಈವೆಂಟ್ ಲಿಸನರ್ ಅನ್ನು ತೆಗೆದುಹಾಕುವುದು

            function* eventListener() {
 try {
 window.addEventListener("resize", handleResize);
 yield;
 } finally {
 window.removeEventListener("resize", handleResize);
 console.log("Event listener removed.");
 }
}

function handleResize() {
 console.log("Window resized.");
}

const listener = eventListener();
listener.next();

setTimeout(() => {
 listener.return(); // remove the event listener after 5 seconds.
}, 5000);

            

              
                Copy
              
            
          

ಉತ್ತಮ ಅಭ್ಯಾಸಗಳು ಮತ್ತು ಪರಿಗಣನೆಗಳು

ಜನರೇಟರ್ ರಿಟರ್ನ್ ಮೌಲ್ಯಗಳೊಂದಿಗೆ ಕೆಲಸ ಮಾಡುವಾಗ, ಈ ಕೆಳಗಿನ ಉತ್ತಮ ಅಭ್ಯಾಸಗಳನ್ನು ಪರಿಗಣಿಸಿ:

• ಅಂತಿಮ ಮೌಲ್ಯವನ್ನು ಹಿಂತಿರುಗಿಸಬೇಕಾದಾಗ return ಅನ್ನು ಸ್ಪಷ್ಟವಾಗಿ ಬಳಸಿ. ಇದು ಇಟರೇಟರ್‌ನ value ಪ್ರಾಪರ್ಟಿಯನ್ನು ಪೂರ್ಣಗೊಂಡ ನಂತರ ಸರಿಯಾಗಿ ಹೊಂದಿಸಲಾಗಿದೆ ಎಂದು ಖಚಿತಪಡಿಸುತ್ತದೆ.
• ಸರಿಯಾದ ಸ್ವಚ್ಛತೆಯನ್ನು ಖಚಿತಪಡಿಸಿಕೊಳ್ಳಲು try...finally ಬ್ಲಾಕ್‌ಗಳನ್ನು ಬಳಸಿ. ಸಂಪನ್ಮೂಲಗಳನ್ನು ನಿರ್ವಹಿಸುವಾಗ ಅಥವಾ ಅಸಿಂಕ್ರೋನಸ್ ಕಾರ್ಯಾಚರಣೆಗಳನ್ನು ನಿರ್ವಹಿಸುವಾಗ ಇದು ವಿಶೇಷವಾಗಿ ಮುಖ್ಯವಾಗಿದೆ.
• return(value) ಮೆಥಡ್ ಅನ್ನು ಸೌಜನ್ಯದಿಂದ ನಿರ್ವಹಿಸಿ. ಇಟರೇಶನ್ ಅಕಾಲಿಕವಾಗಿ ಕೊನೆಗೊಂಡಾಗ ಕಾರ್ಯಾಚರಣೆಗಳನ್ನು ರದ್ದುಗೊಳಿಸಲು ಅಥವಾ ಸಂಪನ್ಮೂಲಗಳನ್ನು ಬಿಡುಗಡೆ ಮಾಡಲು ಒಂದು ವ್ಯವಸ್ಥೆಯನ್ನು ಒದಗಿಸಿ.
• ಕಾರ್ಯಗತಗೊಳಿಸುವಿಕೆಯ ಕ್ರಮದ ಬಗ್ಗೆ ತಿಳಿದಿರಲಿ. finally ಬ್ಲಾಕ್ return ಸ್ಟೇಟ್‌ಮೆಂಟ್‌ಗಿಂತ ಮೊದಲು ಕಾರ್ಯಗತಗೊಳ್ಳುತ್ತದೆ, ಆದ್ದರಿಂದ ಅಂತಿಮ ಮೌಲ್ಯವನ್ನು ಹಿಂತಿರುಗಿಸುವ ಮೊದಲು ಯಾವುದೇ ಸ್ವಚ್ಛತಾ ತರ್ಕವನ್ನು ನಿರ್ವಹಿಸಲಾಗಿದೆಯೆ ಎಂದು ಖಚಿತಪಡಿಸಿಕೊಳ್ಳಿ.
• ಬ್ರೌಸರ್ ಹೊಂದಾಣಿಕೆಯನ್ನು ಪರಿಗಣಿಸಿ. ಜನರೇಟರ್‌ಗಳು ಮತ್ತು ವರ್ಧಿತ ಇಟರೇಟರ್ ಪ್ರೋಟೋಕಾಲ್ ವ್ಯಾಪಕವಾಗಿ ಬೆಂಬಲಿತವಾಗಿದ್ದರೂ, ಹಳೆಯ ಬ್ರೌಸರ್‌ಗಳೊಂದಿಗೆ ಹೊಂದಾಣಿಕೆಯನ್ನು ಪರಿಶೀಲಿಸುವುದು ಮತ್ತು ಅಗತ್ಯವಿದ್ದರೆ ಪಾಲಿಫಿಲ್ ಬಳಸುವುದು ಮುಖ್ಯವಾಗಿದೆ.

ವಿಶ್ವದಾದ್ಯಂತ ಜನರೇಟರ್ ಬಳಕೆಯ ಪ್ರಕರಣಗಳು

ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ಜನರೇಟರ್‌ಗಳು ಕಸ್ಟಮ್ ಇಟರೇಶನ್ ಅನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸಲು ಒಂದು ಹೊಂದಿಕೊಳ್ಳುವ ಮಾರ್ಗವನ್ನು ಒದಗಿಸುತ್ತವೆ. ಜಾಗತಿಕವಾಗಿ ಅವು ಉಪಯುಕ್ತವಾಗಿರುವ ಕೆಲವು ಸನ್ನಿವೇಶಗಳು ಇಲ್ಲಿವೆ:

• ದೊಡ್ಡ ಡೇಟಾಸೆಟ್‌ಗಳನ್ನು ಪ್ರಕ್ರಿಯೆಗೊಳಿಸುವುದು: ಬೃಹತ್ ವೈಜ್ಞಾನಿಕ ಡೇಟಾಸೆಟ್‌ಗಳನ್ನು ವಿಶ್ಲೇಷಿಸುವುದನ್ನು ಕಲ್ಪಿಸಿಕೊಳ್ಳಿ. ಜನರೇಟರ್‌ಗಳು ಡೇಟಾವನ್ನು ತುಣುಕು-ತುಣುಕಾಗಿ ಪ್ರಕ್ರಿಯೆಗೊಳಿಸಬಹುದು, ಮೆಮೊರಿ ಬಳಕೆಯನ್ನು ಕಡಿಮೆ ಮಾಡುತ್ತದೆ ಮತ್ತು ಸುಗಮ ವಿಶ್ಲೇಷಣೆಯನ್ನು ಸಕ್ರಿಯಗೊಳಿಸುತ್ತದೆ. ಇದು ವಿಶ್ವದಾದ್ಯಂತ ಸಂಶೋಧನಾ ಪ್ರಯೋಗಾಲಯಗಳಲ್ಲಿ ಮುಖ್ಯವಾಗಿದೆ.
• ಬಾಹ್ಯ APIಗಳಿಂದ ಡೇಟಾವನ್ನು ಓದುವುದು: ಪೇಜಿನೇಶನ್ ಅನ್ನು ಬೆಂಬಲಿಸುವ APIಗಳಿಂದ (ಸಾಮಾಜಿಕ ಮಾಧ್ಯಮ APIಗಳು ಅಥವಾ ಹಣಕಾಸು ಡೇಟಾ ಪೂರೈಕೆದಾರರಂತಹ) ಡೇಟಾವನ್ನು ಪಡೆಯುವಾಗ, ಜನರೇಟರ್‌ಗಳು API ಕರೆಗಳ ಅನುಕ್ರಮವನ್ನು ನಿರ್ವಹಿಸಬಹುದು, ಫಲಿತಾಂಶಗಳು ಬಂದಂತೆ ಅವುಗಳನ್ನು ನೀಡುತ್ತವೆ. ನಿಧಾನಗತಿಯ ಅಥವಾ ವಿಶ್ವಾಸಾರ್ಹವಲ್ಲದ ನೆಟ್‌ವರ್ಕ್ ಸಂಪರ್ಕಗಳಿರುವ ಪ್ರದೇಶಗಳಲ್ಲಿ ಇದು ಉಪಯುಕ್ತವಾಗಿದೆ, ಇದು ಸ್ಥಿತಿಸ್ಥಾಪಕ ಡೇಟಾ ಮರುಪಡೆಯುವಿಕೆಗೆ ಅನುವು ಮಾಡಿಕೊಡುತ್ತದೆ.
• ನೈಜ-ಸಮಯದ ಡೇಟಾ ಸ್ಟ್ರೀಮ್‌ಗಳನ್ನು ಅನುಕರಿಸುವುದು: ಡೇಟಾ ಸ್ಟ್ರೀಮ್‌ಗಳನ್ನು ಅನುಕರಿಸಲು ಜನರೇಟರ್‌ಗಳು ಅತ್ಯುತ್ತಮವಾಗಿವೆ, ಇದು ಹಣಕಾಸು (ಸ್ಟಾಕ್ ಬೆಲೆಗಳನ್ನು ಅನುಕರಿಸುವುದು) ಅಥವಾ ಪರಿಸರ ಮೇಲ್ವಿಚಾರಣೆ (ಸೆನ್ಸರ್ ಡೇಟಾವನ್ನು ಅನುಕರಿಸುವುದು) ನಂತಹ ಅನೇಕ ಕ್ಷೇತ್ರಗಳಲ್ಲಿ ಅತ್ಯಗತ್ಯ. ಸ್ಟ್ರೀಮಿಂಗ್ ಡೇಟಾದೊಂದಿಗೆ ಕೆಲಸ ಮಾಡುವ ಅಲ್ಗಾರಿದಮ್‌ಗಳನ್ನು ತರಬೇತಿ ಮತ್ತು ಪರೀಕ್ಷಿಸಲು ಇದನ್ನು ಬಳಸಬಹುದು.
• ಸಂಕೀರ್ಣ ಲೆಕ್ಕಾಚಾರಗಳ ಲೇಜಿ ಮೌಲ್ಯಮಾಪನ: ಜನರೇಟರ್‌ಗಳು ತಮ್ಮ ಫಲಿತಾಂಶವು ಅಗತ್ಯವಿದ್ದಾಗ ಮಾತ್ರ ಲೆಕ್ಕಾಚಾರಗಳನ್ನು ನಿರ್ವಹಿಸಬಹುದು, ಸಂಸ್ಕರಣಾ ಶಕ್ತಿಯನ್ನು ಉಳಿಸುತ್ತದೆ. ಎಂಬೆಡೆಡ್ ಸಿಸ್ಟಮ್‌ಗಳು ಅಥವಾ ಮೊಬೈಲ್ ಸಾಧನಗಳಂತಹ ಸೀಮಿತ ಸಂಸ್ಕರಣಾ ಶಕ್ತಿಯಿರುವ ಪ್ರದೇಶಗಳಲ್ಲಿ ಇದನ್ನು ಬಳಸಬಹುದು.

ತೀರ್ಮಾನ

ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ಜನರೇಟರ್‌ಗಳು, return ಸ್ಟೇಟ್‌ಮೆಂಟ್ ಮತ್ತು ವರ್ಧಿತ ಇಟರೇಟರ್ ಪ್ರೋಟೋಕಾಲ್‌ನ ದೃಢವಾದ ತಿಳುವಳಿಕೆಯೊಂದಿಗೆ ಸೇರಿ, ಡೆವಲಪರ್‌ಗಳಿಗೆ ಹೆಚ್ಚು ದಕ್ಷ, ದೃಢವಾದ, ಮತ್ತು ನಿರ್ವಹಿಸಬಹುದಾದ ಕೋಡ್ ಅನ್ನು ರಚಿಸಲು ಅಧಿಕಾರ ನೀಡುತ್ತವೆ. ಈ ವೈಶಿಷ್ಟ್ಯಗಳನ್ನು ಬಳಸಿಕೊಳ್ಳುವ ಮೂಲಕ, ನೀವು ಸಂಪನ್ಮೂಲಗಳನ್ನು ಪರಿಣಾಮಕಾರಿಯಾಗಿ ನಿರ್ವಹಿಸಬಹುದು, ರದ್ದತಿಯೊಂದಿಗೆ ಅಸಿಂಕ್ರೋನಸ್ ಕಾರ್ಯಾಚರಣೆಗಳನ್ನು ನಿಭಾಯಿಸಬಹುದು, ಮತ್ತು ಸಂಕೀರ್ಣ ಇಟರೇಬಲ್ ಆಬ್ಜೆಕ್ಟ್‌ಗಳನ್ನು ಸುಲಭವಾಗಿ ನಿರ್ಮಿಸಬಹುದು. ಜನರೇಟರ್‌ಗಳ ಶಕ್ತಿಯನ್ನು ಅಳವಡಿಸಿಕೊಳ್ಳಿ ಮತ್ತು ನಿಮ್ಮ ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ಅಭಿವೃದ್ಧಿ ಪಯಣದಲ್ಲಿ ಹೊಸ ಸಾಧ್ಯತೆಗಳನ್ನು ಅನ್ಲಾಕ್ ಮಾಡಿ.